   import numpy as np
# Series:一维带标签的数组
# DataFrame:二位，Series容器
import pandas as pd

t1 = pd.Series(range(10))
# print(t1)
'''
0    0
1    1
2    2
3    3
4    4
5    5
6    6
7    7
8    8
9    9
dtype: int64
'''
# 通过索引拿到值
# print(t1[1])  #1

# Series的切片操作
# print(t1[:2])
'''
0    0
1    1
dtype: int64
'''
# print(t1[[0,3,4]])
'''
0    0
3    3
4    4
dtype: int64
'''
# 布尔索引
# print(t1[t1>3])
'''
4    4
5    5
6    6
7    7
8    8
9    9
dtype: int64
'''

# 获取索引列表 index
#print(t1.index) #RangeIndex(start=0, stop=10, step=1)
# print(list(t1.index)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 获取value
# print(t1.values)  #[0 1 2 3 4 5 6 7 8 9] 类型为numpy.ndarray

'''
Series本质是由两个数组构成，一个对象构成数组的建（index,索引），
一个数组构成对象的值（values）
键->值
'''
# t2 = pd.Series([1,'po',4])
# print(type(t2[1]))

'''
在DataFrame里面，一行代表一条数据
DataFrame的一些基本属性：
   df.shape  #行数，列数
   df.dtypes #列数据类型
   df.ndim  #数据维度
   df.index  #行索引
   df.colunms #列索引
   df.values #对象值，二维ndarray数组
'''
t2 = {'name':[7,8,9],'age':[8,19,20],'tel':[10086,189,139]}
df1 = pd.DataFrame(t2)
# print(df1)
'''
name  age    tel
0   hd   18  10086
1  hd1   19    189
2  hd2   20    139
'''
# print(df1.shape)   #(3,3)
# print(df1.dtypes)
'''
name    object
age      int64
tel      int64
dtype: object

'''
# print(df1.ndim)   #2
# print(df1.index)  #RangeIndex(start=0, stop=3, step=1)
# print(df1.values)
'''
[['hd' 18 10086]
 ['hd1' 19 189]
 ['hd2' 20 139]]
'''


'''
df.head()  #显示前五行
df.tail()  #显示后5行
df.head()  #快速综合统计结果，计数，均值，标准差，最大值，四分位数，最小值
df.info()  #相关信息概述
df.sort_values(by=‘##’,axis=0,ascending=True, inplace=False, na_position=‘last’)
   by:指定列名(axis=0或’index’)或索引值(axis=1或’columns’)
   axis:若axis=0或’index’，则按照指定列中数据大小排序；若axis=1或’columns’，则按照指定索引中数据大小排序，默认axis=0
   ascending:是否按指定列的数组升序排列，默认为True，即升序排列
   inplace:是否用排序后的数据集替换原来的数据，默认为False，即不替换
   na_position:{‘first’,‘last’}，设定缺失值的显示位置
'''
# print(df1.dtypes)
# print(df1.sort_values(by='age',ascending=False))
'''
  name  age    tel
2  hd2   20    139
1  hd1   19    189
0   hd    8  10086
'''
# print(df1[:])

'''
pandas取行或取列时得注意点
   方括号写数字，表示取行，对行进行操作
   写字符串表示取列，对列进行操作
'''
# print(df1[1:3])  #取第一和第二行
'''
 name  age  tel
1  hd1   19  189
2  hd2   20  139
'''
# print(df1['age'])
'''
0     8
1    19
2    20
Name: age, dtype: int64
'''

'''
df.loc[]:通过标签进行索引数据
df.iloc[]:通过位置进行索引数据
'''
# print(df1)
# print(df1.loc[1,'age'])  #19
# print(df1.loc[:,'age'])
'''
0     8
1    19
2    20
'''
# print(df1.loc[[0,2],['name','age']])
'''
  name  age
0   hd    8
2  hd2   20
'''
# print(df1.iloc[1,2])  #189
# print(df1.iloc[:1,:2])
'''
 name  age
0   hd    8
'''

'''
pandas的bool索引：

'''
# print(df1[df1['age']>10])
'''
 name  age  tel
1  hd1   19  189
2  hd2   20  139
'''
# print(df1[(df1['age']>10) & (df1['age']<20)])
'''
  name  age  tel
1  hd1   19  189
'''

'''
pd.isnull(df1)或者df1.isnull：检查DataFrame对象(df1)中的空值，并返回一个Boolean数组
pd.notnull(df1)df1.notnull:检查DataFrame对象（df1）中的非空值，并返回一个Boolean数组
'''
# all()：所有为true，返回true
# .any():有一个true，则返回true

'''
df.dropna():清洗数据
参数：
  axis：默认为 0，表示逢空值剔除整行，如果设置参数 axis＝1 表示逢空值去掉整列。
  how：默认为 'any' 如果一行（或一列）里任何一个数据有出现 NA 就去掉整行，如果设置 how='all' 一行（或列）都是 NA 才去掉这整行。
  thresh：设置需要多少非空值的数据才可以保留下来的。
  subset：设置想要检查的列。如果是多个列，可以使用列名的 list 作为参数。
  inplace：如果设置 True，将计算得到的值直接覆盖之前的值并返回 None，修改的是源数据
  
df.drop()
参数：
   labels：按照标签删除对应的行或列，接受单个标签或是一个列表。
   axis：指出需要删除的是行（0或index，）还s是列（1或columns），default = 0.默认为0
   index\columns:0.21.0版本之后，可以通过直接指定index= 来代替“label= ，axis=”。可以传入单个标签或是一个列表。
   level:针对多级标签。多级标签计算时，从0开始
   inplace:同dropna中效果一样，删除数据后自动赋值。
   errors：如果传入的标签不存在，会报错，KeyError，errors可以忽略报错。可选择raise和ignore，default=raise
'''
'''
fillna()：填充NA/NaN值
参数：
   value：用于填充的空值的值。
   method： {'backfill', 'bfill', 'pad', 'ffill', None}, default None。定义了填充空值的方法， pad / ffill表示用前面行/列的值，填充当前行/列的空值， backfill / bfill表示用后面行/列的值，填充当前行/列的空值。
   axis：轴。0或'index'，表示按行删除；1或'columns'，表示按列删除。
   inplace：是否原地替换。布尔值，默认为False。如果为True，则在原DataFrame上进行操作，返回值为None。
   limit：int， default None。如果method被指定，对于连续的空值，这段连续区域，最多填充前 limit 个空值（如果存在多段连续区域，每段最多填充前 limit 个空值）。如果method未被指定， 在该axis下，最多填充前 limit 个空值（不论空值连续区间是否间断）
   downcast：dict, default is None，字典中的项为，为类型向下转换规则。或者为字符串“infer”，此时会在合适的等价类型之间进行向下转换，比如float64 to int64 if possible。

'''

# 在pandas中，计算平均值可以直接计算，有nan也没事，替换df1中的0，df1[df1==0] = np.nan
# 计算平均值时0是会参与计算的，nan不会参与计算

# print(df1)
df1.loc[1,'age'] = np.nan
# print(df1)
# from sklearn.impute import SimpleImputer
# my_imputer = SimpleImputer()
# df1_1 = pd.DataFrame(my_imputer.fit_transform(df1))
#
# # df1_1.columns = ['q','w','e']
# print(df1_1)

print(df1.isnull().sum())

s = (df1.dtypes == 'int64')
print(s.isnull())
# print(s[s].index)

'''
DataFrame.select_dtypes(include=None, exclude=None)[source]
   根据列dtypes返回DataFrame的列的子集,要包含/排除的dtype或字符串的选择。必须提供这些参数中的至少一个。
   df.select_dtypes(include = ['int64','float64'])
'''

'''
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
       keys=None, levels=None, names=None, verify_integrity=False)
       参数：
        objs: series，dataframe或者是panel构成的序列lsit 
        axis： 需要合并链接的轴，0是行，1是列 
        join：连接的方式 inner，或者outer，如果为’inner’得到的是两表的交集，如果是outer，得到的是两表的并集   
'''


te = pd.DataFrame({'card':[True,False,False],'spend':['q','w','e']})
print(te)
y = te.card
print(y)
x = te.spend
print(x)
print(x[~y])
#%%
'''
sort_index()和.sort_values()
 1. df. sort_values()
  作用：既可以根据列数据，也可根据行数据排序。
  注意：必须指定by参数，即必须指定哪几行或哪几列；无法根据index名和columns名排序（由.sort_index()执行）
  
  DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')

 参数：
  axis：{0 or ‘index’, 1 or ‘columns’}, default 0，默认按照列排序，即纵向排序；如果为1，则是横向排序。
  by：str or list of str；如果axis=0，那么by="列名"；如果axis=1，那么by="行名"。
  ascending：布尔型，True则升序，如果by=['列名1','列名2']，则该参数可以是[True, False]，即第一字段升序，第二个降序。
  inplace：布尔型，是否用排序后的数据框替换现有的数据框。
  kind：排序方法，{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。似乎不用太关心。
  na_position：{‘first’, ‘last’}, default ‘last’，默认缺失值排在最后面。


 2. df. sort_index()
  作用：默认根据行标签对所有行排序，或根据列标签对所有列排序，或根据指定某列或某几列对行排序。
  注意：df. sort_index()可以完成和df. sort_values()完全相同的功能，但python更推荐用只用df. sort_index()对“根据行标签”和“根据列标签”排序，其他排序方式用df.sort_values()。

  sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, by=None)

 参数：
  xis：0按照行名排序；1按照列名排序
  level：默认None，否则按照给定的level顺序排列---貌似并不是，文档
  ascending：默认True升序排列；False降序排列
  nplace：默认False，否则排序之后的数据直接替换原来的数据框
  kind：排序方法，{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。似乎不用太关心。
  na_position：缺失值默认排在最后{"first","last"}
  by：按照某一列或几列数据进行排序，但是by参数貌似不建议使用

'''
#%%
'''
shift():该函数主要的功能就是使数据框中的数据移动

 参数详解：
  period：表示移动的幅度，可以是正数，也可以是负数，默认值是1,1就表示移动一次，注意这里移动的都是数据，而索引是不移动的，移动之后没有对应值的，就赋值为NaN。
  freq： DateOffset, timedelta, or time rule string，可选参数，默认值为None，只适用于时间序列，如果这个参数存在，那么会按照参数值移动时间索引，而数据值没有发生变化。
  axis： {0, 1, ‘index', ‘columns'}，表示移动的方向，如果是0或者'index'表示上下移动，如果是1或者'columns'，则会左右移动。
'''
s1 = pd.Series([0,1,2,3])
print(s1)
'''
0	0
1	1
2	2
3	3
'''
print(s1.shift(2))
'''
0    NaN
1    NaN
2    0.0
3    1.0
'''

'''
df.reindex()允许你修改、增加、删除指定轴上的索引，并返回一个数据副本。
   df1 = df.reindex(index=dates[0:4], columns=list(df.columns)+['E'])
'''
'''
df.apply(function,axis):对一行或一列做出一些操作（axis=1遍历行，axis=0遍历列),axis默认等于0
'''

'''
value_counts()是一种查看表格某列中有多少个不同值的快捷方法，并计算每个不同值有在该列中有多少重复值
 value_counts()是Series拥有的方法，一般在DataFrame中使用时，需要指定对哪一列或行使用
'''
